package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade PREFERENCIAS_USUARIOS
 * @author Gerado pelo Telescope
 */
public class EntPreferenciasUsuarios extends AssociativeEntity {
    
    public final static String ENTITY_NAME = "RTPREF.PREFERENCIAS_USUARIOS";
    public final static String TABLE_NAME = "PREFERENCIAS_USUARIOS";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntPreferenciasUsuarios() {
        super();
        initialize();
    }
    
    public EntPreferenciasUsuarios(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aUsuarioId = new DomId(this,"USUARIO_ID", "Usuário"); 
        aUsuarioId.setRequired(true);
        oUsuarioId = new DomId();
        aPreferenciaId = new DomId(this,"PREFERENCIA_ID", "Preferência"); 
        aPreferenciaId.setRequired(true);
        oPreferenciaId = new DomId();
        aValor = new DomTextLong(this,"VALOR", "Valor"); 
        oValor = new DomTextLong();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Usuário
    private DomId aUsuarioId;
    private DomId oUsuarioId;
    
    // Preferência
    private DomId aPreferenciaId;
    private DomId oPreferenciaId;
    
    // Valor
    private DomTextLong aValor;
    private DomTextLong oValor;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntPreferenciasUsuarios id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo USUARIO_ID">
    
    public EntPreferenciasUsuarios usuarioId(Long value) {
        setUsuarioId(value);
        return this;
    }
    
    public void setUsuarioId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyUsuarioId();
        } else {
            aUsuarioId.setValue(value.getValue());
            if (aUsuarioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setUsuarioId(String value) {
        if (value == null) {
            nullifyUsuarioId();
        } else {
            aUsuarioId.setValue(value);
            if (aUsuarioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setUsuarioId(Long value) {
        aUsuarioId.setValue(value);
        if (aUsuarioId.isModified()) {
            setModified(true);
        }
    }
    
    public void setUsuarioId(Object value) {
        aUsuarioId.setValue(value);
        if (aUsuarioId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyUsuarioId() {
        if (!aUsuarioId.isNull()) {
            aUsuarioId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getUsuarioId() {
        return aUsuarioId;
    }
    
    public DomId oldUsuarioId() {
        return oUsuarioId;
    }
    
    public Long valueOfUsuarioId() {
        return aUsuarioId.getValue();
    }
    
    public boolean isUsuarioIdModified() {
        return aUsuarioId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PREFERENCIA_ID">
    
    public EntPreferenciasUsuarios preferenciaId(Long value) {
        setPreferenciaId(value);
        return this;
    }
    
    public void setPreferenciaId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyPreferenciaId();
        } else {
            aPreferenciaId.setValue(value.getValue());
            if (aPreferenciaId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPreferenciaId(String value) {
        if (value == null) {
            nullifyPreferenciaId();
        } else {
            aPreferenciaId.setValue(value);
            if (aPreferenciaId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPreferenciaId(Long value) {
        aPreferenciaId.setValue(value);
        if (aPreferenciaId.isModified()) {
            setModified(true);
        }
    }
    
    public void setPreferenciaId(Object value) {
        aPreferenciaId.setValue(value);
        if (aPreferenciaId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPreferenciaId() {
        if (!aPreferenciaId.isNull()) {
            aPreferenciaId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getPreferenciaId() {
        return aPreferenciaId;
    }
    
    public DomId oldPreferenciaId() {
        return oPreferenciaId;
    }
    
    public Long valueOfPreferenciaId() {
        return aPreferenciaId.getValue();
    }
    
    public boolean isPreferenciaIdModified() {
        return aPreferenciaId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VALOR">
    
    public EntPreferenciasUsuarios valor(String value) {
        setValor(value);
        return this;
    }
    
    public void setValor(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyValor();
        } else {
            aValor.setValue(value.getValue());
            if (aValor.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValor(String value) {
        if (value == null) {
            nullifyValor();
        } else {
            aValor.setValue(value);
            if (aValor.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValor(Object value) {
        aValor.setValue(value);
        if (aValor.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyValor() {
        if (!aValor.isNull()) {
            aValor.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getValor() {
        return aValor;
    }
    
    public DomTextLong oldValor() {
        return oValor;
    }
    
    public String valueOfValor() {
        return aValor.getValue();
    }
    
    public boolean isValorModified() {
        return aValor.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            e = new AdsException("RTPREF.PREFERENCIAS_USUARIOS.GET_ERRORS_UNKNOWN",
                    AdsException.UNKNOWN,
                    "Erro não esperado: " + errorMsg);
        } else {
            if (msg.indexOf("PK_PRUS") >= 0) {
                e = new AdsException("RTPREF.PREFERENCIAS_USUARIOS.PK_PRUS", 
                        Severity.ERROR,
                        "ID duplicado! (PK_PRUS)");
                return e;
            } else if (msg.indexOf("FK_PRUS_USUA_USUARIO") >= 0) {
                e = new AdsException("RTPREF.PREFERENCIAS_USUARIOS.FK_PRUS_USUA_USUARIO", 
                        Severity.ERROR,
                        "Registro não cadastrado para USUARIO! (FK_PRUS_USUA_USUARIO)");
                return e;
            } else if (msg.indexOf("UK_PRUS_PROPRIEDADE_USUARIO") >= 0) {
                e = new AdsException("RTPREF.PREFERENCIAS_USUARIOS.UK_PRUS_PROPRIEDADE_USUARIO", 
                        Severity.ERROR,
                        "Registro duplicado! Esta preferência já está cadastrada para este usuário! Preferência ${PREFERENCIA_ID}, Usuário ${USUARIO_ID} (UK_PRUS_PROPRIEDADE_USUARIO)");
                return e;
            } else if (msg.indexOf("FK_PRUS_PREF") >= 0) {
                e = new AdsException("RTPREF.PREFERENCIAS_USUARIOS.FK_PRUS_PREF", 
                        Severity.ERROR,
                        "Registro não cadastrado para PREFERENCIA! (FK_PRUS_PREF)");
                return e;
            } else {
                e = new AdsException("RTPREF.PREFERENCIAS_USUARIOS.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aUsuarioId);
            allAttributes.add(aPreferenciaId);
            allAttributes.add(aValor);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getPreferenciaId().toString() +
                " " + getUsuarioId().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    /**
     * Métodos de manipulação dos IDs das entidades associadas
     */
    public DomId getAssociationId1() {
        return getPreferenciaId();
    }
    public DomId getAssociationId2() {
        return getUsuarioId();
    }
    public void setAssociationId1(long id) {
        setPreferenciaId(id);
    }
    public void setAssociationId2(long id) {
        setUsuarioId(id);
    }
    
    public void findByPreferenciaIdUsuarioId(long preferenciaId, long usuarioId) throws AdsException {
        findBy(new String[] {"PREFERENCIA_ID", "USUARIO_ID"},
                new Object[] {preferenciaId, usuarioId});
    }
    
    private EntUsuarios eUsuario;
    
    public EntUsuarios findUsuario() throws AdsException {
        if (getUsuarioId().isNull()) {
            return null;
        }
        if (eUsuario == null || !valueOfUsuarioId().equals(eUsuario.valueOfId())) {
            eUsuario = new EntUsuarios(ctx);
            eUsuario.find(valueOfUsuarioId());
        }
        return eUsuario;
    }
    
    /**
     * Ativa o join desta entidade com USUARIOS
     * através do atributo USUARIO_ID
     */
    public EntUsuarios joinUsuario() {
        return joinUsuario(null);
    }
    public EntUsuarios joinUsuario(String alias) {
        EntUsuarios entity = new EntUsuarios(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getUsuarioId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByUsuario(long id, String sqlAppend) throws AdsException {
        find("select ID from PREFERENCIAS_USUARIOS where USUARIO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByUsuario(long id) throws AdsException {
        findByUsuario(id,"");
    }
    
    public void findByUsuario(Entity entidade) throws AdsException {
        findByUsuario(entidade.valueOfId(),"");
    }
    
    public void findByUsuario(Entity entidade, String sqlAppend) throws AdsException {
        findByUsuario(entidade.valueOfId(),sqlAppend);
    }
    
    private EntPreferencias ePreferencia;
    
    public EntPreferencias findPreferencia() throws AdsException {
        if (getPreferenciaId().isNull()) {
            return null;
        }
        if (ePreferencia == null || !valueOfPreferenciaId().equals(ePreferencia.valueOfId())) {
            ePreferencia = new EntPreferencias(ctx);
            ePreferencia.find(valueOfPreferenciaId());
        }
        return ePreferencia;
    }
    
    /**
     * Ativa o join desta entidade com PREFERENCIAS
     * através do atributo PREFERENCIA_ID
     */
    public EntPreferencias joinPreferencia() {
        return joinPreferencia(null);
    }
    public EntPreferencias joinPreferencia(String alias) {
        EntPreferencias entity = new EntPreferencias(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getPreferenciaId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByPreferencia(long id, String sqlAppend) throws AdsException {
        find("select ID from PREFERENCIAS_USUARIOS where PREFERENCIA_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByPreferencia(long id) throws AdsException {
        findByPreferencia(id,"");
    }
    
    public void findByPreferencia(Entity entidade) throws AdsException {
        findByPreferencia(entidade.valueOfId(),"");
    }
    
    public void findByPreferencia(Entity entidade, String sqlAppend) throws AdsException {
        findByPreferencia(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eUsuario = null;
        ePreferencia = null;
    }
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oUsuarioId.setValue(aUsuarioId);
        oValor.setValue(aValor);
        oPreferenciaId.setValue(aPreferenciaId);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntPreferenciasUsuarios.class);
            rule.setName("UK_PRUS_PROPRIEDADE_USUARIO");
            rule.addAttribute(new DomId("PREFERENCIA_ID",""));
            rule.addAttribute(new DomId("USUARIO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntPreferenciasUsuarios.class);
            rule.setAssociatedEntity(EntPreferencias.class);
            rule.setName("FK_PRUS_PREF");
            rule.addAttribute(new DomId("PREFERENCIA_ID",""));
            out.add(rule);
        }
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntPreferenciasUsuarios.class);
            rule.setName("PK_PRUS");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntPreferenciasUsuarios.class);
            rule.setAssociatedEntity(EntUsuarios.class);
            rule.setName("FK_PRUS_USUA_USUARIO");
            rule.addAttribute(new DomId("USUARIO_ID",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Lookup do valor para o usuário.
     * <p>
     * Este método busca o valor da preferência a partir do nome informado da 
     * mesma e faz a respectiva leitura.
     */
    public void lookup(String preferencia) throws AdsException {
        // <user-code id="101400" parentId="101396" hashcode="-796750d9" length="690">
        EntPreferencias pref = new EntPreferencias(ads);
        try {
            pref.findByPreferencia(preferencia);
        } catch (RecordNotFoundException e) {
            pref.setPreferencia(preferencia);
            pref.setPorUsuario("S");
            pref.setDescricao("Inserido automaticamente!");
            pref.setDominio("ADSRT.TEXT");
            pref.ins();
        }
        
        setPreferenciaId(pref.valueOfId());
        
        if (getUsuarioId().isNull()) {
            setUsuarioId(ads.getUserId());
        }
        
        try {
            findByPreferenciaIdUsuarioId(valueOfPreferenciaId(), valueOfUsuarioId());
        } catch (AdsException e) {
            // Não encontrou valor específico para o usuário
            // Então seta o valor padrão para a preferencia
            setValor(pref.valueOfValor());
        }
        
        // </user-code>
    }
    
    /**
     * Atualizar a propriedade do usuário.
     * <p>
     * Este procedimento é utilizado para atualizar uma propriedade do 
     * usuário e tem como objetivo manter a integridade dos dados, pois 
     * exclui propriedades desnecessárias (delete) ou altera o valor da 
     * propriedade corrente (update).
     * <P>
     * 
     * <P>
     * Obs.: se a propriedade global não esteja para o contexto "por usuário" 
     * ou, o valor da propriedade do usuário seja igual ao valor da 
     * propriedade global, o procedimento excluíra a propriedade do usuário.
     * <P>
     */
    public void update() throws AdsException {
        // <user-code id="29759" parentId="29755" hashcode="-5898693c" length="570">
        EntPreferencias pref = findPreferencia();
        if (pref.valueOfPorUsuario().equals("N")) {
            throw new AdsException( 
                "RTPREF.PREFERENCIAS_USUARIOS.UPDATE.INVALID_ACCESS",
                AdsException.UNKNOWN,
                "Acesso inválido - Usuário não pode alterar valor da preferência");
        } else {
            if (getId().isNull()) {
                if (!valueOfValor().equals(pref.valueOfValor())) {
                    ins();
                }
            } else {
                if (!valueOfValor().equals(pref.valueOfValor())) {
                    del();
                } else {
                    upd();
                }
            }
        }
        // </user-code>
    }
}
